home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / Tool Chest / Toolbox / kcapApp 1.2 / kcapApp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-09  |  14.6 KB  |  531 lines  |  [TEXT/MPS ]
  1. /* kcapApp */
  2. /* demonstration keyboard drawing from KCAP resource */
  3.  
  4. /* Greg Robbins 12/91 */
  5.  
  6. /* includes code stolen from Bo3b's TubeTest */
  7.  
  8. /* version 1.1, 2/92: uses RGetResource rather than GetResource for KCAP;
  9.                   gets KCHR number from script manager */
  10.  
  11. /* version 1.2, 2/92: adds menu of KCAP IDs, displays virtual keycodes */
  12.                   
  13.  
  14. #include <Types.h>
  15. #include <Memory.h>
  16. #include <Quickdraw.h>
  17. #include <Fonts.h>
  18. #include <Events.h>
  19. #include <Menus.h>
  20. #include <Windows.h>
  21. #include <Resources.h>
  22. #include <Dialogs.h>
  23. #include <Desk.h>
  24. #include <Scrap.h>
  25. #include <OSUtils.h>
  26. #include <ToolUtils.h>
  27. #include <SegLoad.h>
  28. #include <SysEqu.h>
  29. #include <Script.h>
  30. #include <Packages.h>
  31. #include <String.h>
  32. #include <Strings.h>
  33. #include <Folders.h>
  34.     
  35. /* Constants */
  36. #define appleID                1000            /* resource IDs/menu IDs for Apple, */
  37. #define fileID                1001            /*     File and */
  38. #define editID                1002            /*    Edit menus */
  39. #define displayID            1003
  40.  
  41. #define appleM                0                /* Index for each menu in myMenus (array of menu handles) */
  42. #define fileM                1
  43. #define editM                2
  44. #define displayM        3
  45.  
  46. #define menuCount            4                /* Total number of menus */
  47.  
  48. #define windowID            1000            /* Resource ID for main window */
  49. #define aboutMeDLOG         1000            /* And Resource ID for About box dialog. */
  50.  
  51. #define quitItem            1                /* Quit in the File menu */
  52.  
  53. #define aboutMeCommand        1                /* Menu item in apple menu for About */
  54.     
  55.     
  56. /* Globals */
  57. MenuHandle myMenus[menuCount];
  58. Rect dragRect;
  59. Boolean    doneFlag;
  60. EventRecord    myEvent;
  61. WindowPtr    myWindow, whichWindow;
  62. char theChar;
  63.  
  64. Boolean    gKeycodesFlag = false;
  65. short    gKcapNum, gCurrDisplayItem;
  66.  
  67. void SetUpMenus();
  68. void DoCommand(long int mResult);
  69. void DrawKeyCaps(short modifiers, short kcharNum, short kcapNum, Boolean keycodesFlag);
  70.  
  71.  
  72. main()
  73. {
  74.     Str255 tempStr, tempStr2;
  75.     StringHandle tempStrHandle;
  76.  
  77.     InitGraf(&qd.thePort);
  78.     InitFonts();
  79.     InitWindows();
  80.     InitMenus();
  81.     TEInit();
  82.     InitDialogs(nil);
  83.     InitCursor();
  84.  
  85.     SetRect(&dragRect, 4, 24, qd.screenBits.bounds.right - 4, qd.screenBits.bounds.bottom - 4);
  86.     doneFlag = false;                            /* flag to detect when Quit command is chosen */
  87.  
  88.     myWindow = GetNewWindow(windowID, nil, (WindowPtr) -1);
  89.     SetPort(myWindow);
  90.  
  91.     SetUpMenus();
  92.     
  93.     /*
  94.     **    Main Event Loop
  95.     */
  96.     do {
  97.         if (WaitNextEvent(everyEvent, &myEvent, 600, nil)) {
  98.             switch (myEvent.what) {                /* case on event type */
  99.  
  100.                 case mouseDown:
  101.                     switch (FindWindow(myEvent.where, &whichWindow)) {
  102.  
  103.                         case inSysWindow:        /* desk accessory window: call Desk Manager to handle it */
  104.                             SystemClick(&myEvent, whichWindow);
  105.                             break;
  106.  
  107.                         case inMenuBar:            /* Menu bar: learn which command, then execute it. */
  108.                             DoCommand(MenuSelect(myEvent.where));
  109.                             break;
  110.  
  111.                         case inDrag:            /* title bar: call Window Manager to drag */
  112.                             DragWindow(whichWindow, myEvent.where, &dragRect);
  113.                             break;
  114.  
  115.                         case inContent:            /* body of application window: */
  116.                             if (whichWindow != FrontWindow())
  117.                                 SelectWindow(whichWindow); /* and make it active if not */
  118.                             break;
  119.                     }
  120.                     break;
  121.  
  122.                 case updateEvt:                    /* Update the window. */
  123.                     if ((WindowPtr) myEvent.message == myWindow) {
  124.                         BeginUpdate((WindowPtr) myEvent.message);
  125.                         
  126.                         /* draw keyboard using current keyboard modifiers, 
  127.                            current KCHR, current keyboard KCAP 
  128.                              
  129.                              see Tech Note 263 for a better way to get the
  130.                              KCHR data under System 7 */
  131.                              
  132.                         DrawKeyCaps(myEvent.modifiers,
  133.                             GetScript(GetEnvirons(smKeyScript), smScriptKeys),
  134.                             gKcapNum, gKeycodesFlag);
  135.  
  136.                         EndUpdate((WindowPtr) myEvent.message);
  137.  
  138.                         /* set window title */
  139.                         NumToString(gKcapNum, tempStr);
  140.                         
  141.                         if (gKeycodesFlag) {
  142.                             /* set window title to "Virtual Keycodes for KCAP ID _" */
  143.                             tempStrHandle = GetString(128);
  144.                             if (tempStrHandle) {
  145.                                 p2cstr(*tempStrHandle);
  146.                                 strcpy(tempStr2, *tempStrHandle);
  147.                                 strcat(tempStr2, p2cstr(tempStr));
  148.                                 SetWTitle(myWindow, c2pstr(tempStr2));
  149.                                 ReleaseResource(tempStrHandle);
  150.                             }
  151.                         }
  152.                         else {
  153.                             tempStrHandle = GetString(129);
  154.                             if (tempStrHandle) {
  155.                             
  156.                                 /* set window title to "Key Labels for KCAP ID _ and KCHR _" */
  157.                                 p2cstr(*tempStrHandle);
  158.                                 strcpy(tempStr2, *tempStrHandle);  /* string */
  159.                                 strcat(tempStr2, p2cstr(tempStr)); /* KCAP # */
  160.                                 ReleaseResource(tempStrHandle);
  161.                                 tempStrHandle = GetString(130);
  162.                                 if (tempStrHandle) {
  163.                                     p2cstr(*tempStrHandle);
  164.                                     strcat(tempStr2, *tempStrHandle); /* string */
  165.                                     
  166.                                     /* get current KCHR number */
  167.                                     NumToString(GetScript(GetEnvirons(smKeyScript), smScriptKeys), tempStr);
  168.                                     strcat(tempStr2, p2cstr(tempStr)); /* KCHR # */
  169.                                     SetWTitle(myWindow, c2pstr(tempStr2));
  170.                                     ReleaseResource(tempStrHandle);
  171.                                 }
  172.                             }
  173.                         }
  174.                     }
  175.                     break;
  176.                             
  177.                 case keyDown:
  178.                 case autoKey:                    /* key pressed once or held down to repeat */
  179.                     if (myWindow == FrontWindow()) {
  180.                         theChar = (myEvent.message & charCodeMask); /* get the char */
  181.                         /* 
  182.                         **    If Command key down, do it as a Menu Command.
  183.                         */
  184.                         if (myEvent.modifiers & cmdKey)
  185.                             DoCommand(MenuKey(theChar));
  186.                         else {
  187.                             EraseRect(&myWindow->portRect);
  188.                             InvalRect(&myWindow->portRect);
  189.                         }
  190.                     }
  191.                     break;
  192.  
  193.             }
  194.         }
  195.  
  196.     } while (!doneFlag);
  197.  
  198.     DisposeWindow (myWindow);
  199. }
  200.  
  201.  
  202. void SetUpMenus()
  203. {
  204.     short i, kcapMaxCount, tempInt;
  205.     Handle kcapHandle;
  206.     Str255 tempStr, kcapStr;
  207.     ResType tempResType;
  208.  
  209.     myMenus[appleM] = GetMenu(appleID);         /* read Apple menu from resource file */
  210.     AddResMenu(myMenus[appleM], 'DRVR');        /* add desk accessory names to Apple menu */
  211.     myMenus[fileM] = GetMenu(fileID);            /* read file menu from resource file */
  212.     myMenus[editM] = GetMenu(editID);            /* read edit menu from resource file */
  213.     DisableItem(myMenus[editM], 0);
  214.     myMenus[displayM] = GetMenu(displayID);            /* read display menu from resource file */
  215.  
  216.     /* add IDs of KCAP resources to display menu */
  217.     gKcapNum = *((char *) KbdType);  /* KCAP ID of current keyboard */
  218.  
  219.     *(short *)RomMapInsert = 0x0100;  /* use ROM resources, SetResLoad(false) */
  220.  
  221.     kcapMaxCount = CountResources('KCAP');
  222.     if (kcapMaxCount > 0) AppendMenu(myMenus[displayM], "\p(-!");
  223.  
  224.     /* add KCAP menu items */
  225.     for (i = 1; i <= kcapMaxCount; i++) {
  226.         *(short *)RomMapInsert = 0x0100;
  227.         kcapHandle = GetIndResource('KCAP', i);
  228.         if (kcapHandle) {
  229.             GetResInfo(kcapHandle, &tempInt, &tempResType, tempStr);
  230.             NumToString(tempInt, tempStr);
  231.             AppendMenu(myMenus[displayM],
  232.                 c2pstr(strcat(strcpy(kcapStr, "KCAP "), p2cstr(tempStr))));
  233.             ReleaseResource(kcapHandle);
  234.             
  235.             if (tempInt == gKcapNum) {
  236.                 CheckItem(myMenus[displayM], i+2, true);
  237.                 gCurrDisplayItem = i+2;
  238.             }
  239.         }
  240.     }
  241.     gKeycodesFlag = false;                    /* not displaying keycodes on keys initially */
  242.     CheckItem(myMenus[displayM], 1, !gKeycodesFlag); /* mark that key labels are displayed */
  243.     
  244.     for (i = 0; i < menuCount; i++) 
  245.         InsertMenu(myMenus[i], 0);                 /* install menus in menu bar */
  246.     
  247.     
  248.     DrawMenuBar();                                /* and draw menu bar */
  249. }
  250.  
  251.  
  252. void ShowAboutMeDialog()
  253. {
  254.     DialogPtr    theDialog;
  255.     short        itemHit;
  256.  
  257.     theDialog = GetNewDialog(aboutMeDLOG, nil, (WindowPtr) -1);
  258.     ModalDialog(nil, &itemHit);
  259.     DisposDialog(theDialog);
  260. }
  261.  
  262.  
  263. /* DrawKeyCaps draws the key caps, given a set of
  264.    modifiers (in the high byte of the short) and
  265.    KCHR and KCAP resource IDs, using the current pen in
  266.    the current GrafPort 
  267.      
  268.      if keycodesFlag is true, the virtual keycodes are drawn
  269.      rather than the key labels.
  270.      
  271.    kcapPtr just bounces along the resource data as we 
  272.      parse it 
  273. */
  274.      
  275. /* see resource type definition on p. 14-101 of IM VI */
  276.      
  277. void DrawKeyCaps(short modifiers, short kchrNum, short kcapNum, Boolean keycodesFlag)
  278. {
  279.     typedef struct {
  280.         char modifierMask;
  281.         char keyCode;
  282.         short deltaV;
  283.         short deltaH;
  284.     } KeyEntryRec;
  285.     
  286.     #define SHAPEMAXPTS 10  /* hopefully, fewer than 10 points per shape */
  287.         
  288.     Rect tempRect;
  289.     Point penPoint, currPoint, swapPoint;
  290.     Point shapePoint[SHAPEMAXPTS];
  291.     Handle kcapResHandle;
  292.     Ptr kcapPtr;
  293.     
  294.     KeyEntryRec thisKeyEntryRec;
  295.     short mainIndex, shapeIndex, keyIndex, shapeTotal, shapeCount;
  296.     short modifiedKeyCode;
  297.     
  298.     FontInfo theFontInfo;
  299.     short fontHeight;
  300.     Point charLoc;
  301.     char theChar;
  302.     
  303.     RgnHandle keyshapeRgnHandle;
  304.     
  305.     Handle kchrResHandle;
  306.     long state;
  307.     
  308.     Str255 keycodeStr;
  309.     short saveTextSize;
  310.  
  311.     GetFontInfo(&theFontInfo);
  312.     fontHeight = theFontInfo.ascent + theFontInfo.descent;
  313.     saveTextSize = myWindow->txSize;
  314.     
  315.     kchrResHandle = RGetResource('KCHR', kchrNum);
  316.     if (ResError() == noErr && kchrResHandle != nil) {
  317.         state = 0;
  318.     
  319.         kcapResHandle = RGetResource('KCAP', kcapNum);
  320.         if (ResError() == noErr && kcapResHandle != nil) {
  321.         
  322.             keyshapeRgnHandle = NewRgn();
  323.             
  324.             MoveHHi(kcapResHandle);
  325.             HLock(kcapResHandle);
  326.             kcapPtr = *kcapResHandle;
  327.             
  328.             /* draw boundary from origin */
  329.             tempRect = *((Rect *) kcapPtr);    
  330.             OffsetRect(&tempRect, - tempRect.left, -tempRect.top);
  331.             EraseRect(&tempRect);                            
  332.             FrameRect(&tempRect);                            
  333.             kcapPtr += sizeof(Rect);
  334.             
  335.             /* draw textedit area */
  336.             tempRect = *((Rect *) kcapPtr);    
  337.             FrameRect(&tempRect);                            
  338.             kcapPtr += sizeof(Rect);
  339.             
  340.             /* loop through main array */
  341.             mainIndex = *((short *) kcapPtr);
  342.             kcapPtr += sizeof(short);
  343.             for ( ; mainIndex>0; mainIndex--) {
  344.             
  345.                 /* loop through shape array - build array of points for this shape */
  346.                 shapeIndex = *((short *) kcapPtr);
  347.                 kcapPtr += sizeof(short);
  348.  
  349.                 shapeTotal = (shapeIndex < SHAPEMAXPTS ? shapeIndex + 1 : SHAPEMAXPTS);
  350.                 for (shapeCount=0; shapeIndex>-1; shapeIndex--, shapeCount++) {
  351.                     shapePoint[shapeCount] = *((Point *) kcapPtr);
  352.                     kcapPtr += sizeof(Point);
  353.                 }
  354.                 
  355.                 /* start drawing keys of this shape from 0,0 */
  356.                 MoveTo(0,0);
  357.                 
  358.                 /* loop through key array */
  359.                 keyIndex = *((short *) kcapPtr);
  360.                 kcapPtr += sizeof(short);
  361.                 for ( ; keyIndex>-1; keyIndex--) {
  362.                 
  363.                     /* get modifier mask, keyCode, and offset from previous key */                    
  364.                     thisKeyEntryRec = *((KeyEntryRec *) kcapPtr);
  365.                     kcapPtr += sizeof(KeyEntryRec);
  366.                     
  367.                     /* move the pen to the start of the key */
  368.                     Move(thisKeyEntryRec.deltaH, thisKeyEntryRec.deltaV);
  369.                     
  370.                     /* draw the key, composed of one or more rects */
  371.                     SetPt(&currPoint, 0, 0);
  372.                     OpenRgn();
  373.                     
  374.                     for (shapeCount=0, shapeIndex=shapeTotal; shapeIndex; 
  375.                                 shapeIndex--, shapeCount++) {
  376.  
  377.                         /* set the rect, then reverse coordinates if necessary 
  378.                            to ensure it is not empty */
  379.                         SetRect(&tempRect, currPoint.h, currPoint.v, 
  380.                             shapePoint[shapeCount].h, shapePoint[shapeCount].v);
  381.                             
  382.                         if (tempRect.top > tempRect.bottom) {
  383.                             swapPoint.v = tempRect.top;
  384.                             tempRect.top = tempRect.bottom;
  385.                             tempRect.bottom = swapPoint.v;
  386.                         }
  387.                         if (tempRect.left > tempRect.right) {
  388.                             swapPoint.h = tempRect.left;
  389.                             tempRect.left = tempRect.right;
  390.                             tempRect.right = swapPoint.h;
  391.                         }
  392.                         
  393.                         /* move the rect to the pen location and add it to the region */
  394.                         currPoint = shapePoint[shapeCount];
  395.                         GetPen(&penPoint);
  396.                         OffsetRect(&tempRect, penPoint.h, penPoint.v);    
  397.                         FrameRect(&tempRect);
  398.                     }
  399.                     
  400.                     /* draw the key frame */
  401.                     CloseRgn(keyshapeRgnHandle);
  402.                     FrameRgn(keyshapeRgnHandle);
  403.                     SetEmptyRgn(keyshapeRgnHandle);
  404.                     
  405.                     /* convert the keyCode to a character code */
  406.                     /* mask out high bit of keyCode and add masked modifiers;
  407.                        KeyTrans stroke bit taken from modifier parameter */
  408.                          
  409.                     if (thisKeyEntryRec.keyCode & 0x80) 
  410.                         modifiers &= (((short) thisKeyEntryRec.modifierMask) << 8);
  411.                     else modifiers |= (((short) thisKeyEntryRec.modifierMask) << 8);
  412.                     
  413.                     modifiedKeyCode =
  414.                         ((thisKeyEntryRec.keyCode & 0x007F) | (modifiers & 0xFF80));
  415.                         
  416.                     theChar = KeyTrans(*kchrResHandle, modifiedKeyCode, &state);
  417.         
  418.                     if (!keycodesFlag) {
  419.                         /* center and draw the character */
  420.                         charLoc.v = 
  421.                             ((tempRect.top + tempRect.bottom) / 2) - (fontHeight / 2);
  422.                         charLoc.v += theFontInfo.ascent;
  423.                         charLoc.h = 
  424.                             ((tempRect.left + tempRect.right) / 2) - (CharWidth(theChar) / 2);
  425.                         MoveTo(charLoc.h, charLoc.v);
  426.                         DrawChar(theChar);
  427.                     } else {
  428.                         /* draw the virtual keycode instead of the key label */
  429.                         TextSize(9);
  430.                         NumToString(modifiedKeyCode & 0x7F, keycodeStr);
  431.                         charLoc.v = 
  432.                             ((tempRect.top + tempRect.bottom) / 2) - (fontHeight / 2);
  433.                         charLoc.v += theFontInfo.ascent;
  434.                         charLoc.h = 
  435.                             ((tempRect.left + tempRect.right) / 2) - (StringWidth(keycodeStr) / 2);
  436.                         MoveTo(charLoc.h, charLoc.v);
  437.                         DrawString(keycodeStr);
  438.                     }
  439.                     
  440.                     /* reposition pen for next key */
  441.                     MoveTo(penPoint.h, penPoint.v);
  442.                 }
  443.             }
  444.             HUnlock(kcapResHandle);
  445.             DisposeRgn(keyshapeRgnHandle);
  446.             
  447.             /* release the KCAP and KCHR unless they're System resources */
  448.             if (HomeResFile(kcapResHandle) > 1) ReleaseResource(kcapResHandle);
  449.         }    
  450.         if (HomeResFile(kchrResHandle) > 1) ReleaseResource(kchrResHandle);
  451.         
  452.         TextSize(saveTextSize);
  453.     }
  454. }
  455.  
  456.  
  457. void DoCommand(long int mResult)
  458. {
  459.     short    theItem,                            /* menu item number from mResult low-order word */
  460.     theMenu;                            /* menu number from mResult high-order word */
  461.     Str255    name;                                /* desk accessory name */
  462.     int        tempInt;
  463.     ResType tempResType;
  464.     Str255 tempStr;
  465.     
  466.     Handle kcapHandle;
  467.     theItem = LoWord(mResult);                    /* call Toolbox Utility routines to */
  468.     theMenu = HiWord(mResult);                    /* set menu item number and menu */
  469.  
  470.     switch (theMenu) {                            /* switch on menu ID */
  471.  
  472.         case appleID:
  473.             if (theItem == aboutMeCommand)
  474.                 ShowAboutMeDialog();
  475.             else {
  476.                     GetItem(myMenus[appleM], theItem, name);
  477.                     tempInt = OpenDeskAcc(name);
  478.                     SetPort(myWindow);
  479.             }
  480.             break;
  481.  
  482.         case fileID:
  483.             if (theItem == quitItem)
  484.                 doneFlag = true;
  485.             break;
  486.  
  487.         case editID:
  488.             if (!SystemEdit(theItem - 1)) {    /* Pass the command on to the Desk Manager. */
  489.                 ; /* do nothing */
  490.             };
  491.             break;
  492.         
  493.         case displayID:
  494.                 
  495.                 if (gCurrDisplayItem != theItem) {
  496.                 
  497.                     if (theItem == 1) {
  498.                         
  499.                         /* display key labels */
  500.                         gKeycodesFlag = !gKeycodesFlag;
  501.                         CheckItem(myMenus[displayM], 1, !gKeycodesFlag);
  502.                         
  503.                     } else {
  504.     
  505.                         *(short *)RomMapInsert = 0x0100;  /* use ROM resources, SetResLoad(false) */
  506.                         kcapHandle = GetIndResource('KCAP', theItem - 2);
  507.     
  508.                         if (kcapHandle) {
  509.                             /* find the ID of the chosen KCAP */
  510.                             GetResInfo(kcapHandle, &gKcapNum, &tempResType, tempStr);
  511.                             ReleaseResource(kcapHandle);
  512.     
  513.                             CheckItem(myMenus[displayM], gCurrDisplayItem, false);
  514.                             CheckItem(myMenus[displayM], theItem, true);
  515.     
  516.                             gCurrDisplayItem = theItem;
  517.                         }
  518.                     }
  519.                     
  520.                     
  521.                     EraseRect(&myWindow->portRect);
  522.                     InvalRect(&myWindow->portRect);
  523.                 }
  524.                                                 
  525.             break;
  526.     }
  527.  
  528.     HiliteMenu(0);                                /* Unhighlight menu title */
  529.                                                 /* (highlighted by MenuSelect) */
  530. }
  531.